// 国际化多语言管理器
class I18nManager {
    constructor() {
        this.currentLanguage = 'zh-CN';
        this.supportedLanguages = ['zh-CN', 'en-US'];
        this.translations = {};
        this.isInitialized = false;
    }

    // 初始化多语言管理器
    async init() {
        try {
            console.log('开始初始化多语言管理器...');
            
            // 从系统设置加载语言配置
            await this.loadLanguageConfig();
            
            // 加载当前语言的翻译文件
            await this.loadTranslations(this.currentLanguage);
            
            // 设置语言切换器
            this.setupLanguageSwitcher();
            
            // 应用当前语言
            this.applyLanguage();
            
            this.isInitialized = true;
            console.log('✅ 多语言管理器初始化完成');
            
        } catch (error) {
            console.error('❌ 多语言管理器初始化失败:', error);
            // 使用默认配置作为降级方案
            this.setupFallbackLanguage();
        }
    }

    // 从系统设置加载语言配置
    async loadLanguageConfig() {
        try {
            // 尝试从系统设置API获取配置
            const response = await apiClient.get('/system-settings');
            if (response.success && response.data) {
                const settings = response.data;
                
                // 如果系统设置中有语言配置，使用它
                if (settings.language) {
                    this.currentLanguage = settings.language.defaultLanguage || 'zh-CN';
                    this.supportedLanguages = settings.language.supportedLanguages || ['zh-CN', 'en-US'];
                }
            }
        } catch (error) {
            console.warn('从系统设置加载语言配置失败，使用默认配置:', error);
        }
        
        // 从本地存储获取用户的语言偏好
        const userLanguage = localStorage.getItem('userLanguage');
        if (userLanguage && this.supportedLanguages.includes(userLanguage)) {
            this.currentLanguage = userLanguage;
        }
    }

    // 加载指定语言的翻译文件
    async loadTranslations(languageCode) {
        try {
            console.log(`正在加载 ${languageCode} 语言包...`);
            
            // 尝试从后端API加载翻译
            const response = await apiClient.get(`/i18n/translations/${languageCode}`);
            if (response.success && response.data) {
                this.translations[languageCode] = response.data;
                console.log(`✅ ${languageCode} 语言包加载成功`);
                return;
            }
        } catch (error) {
            console.warn(`从API加载 ${languageCode} 语言包失败:`, error);
        }
        
        // 如果API失败，使用本地默认翻译
        this.translations[languageCode] = this.getDefaultTranslations(languageCode);
        console.log(`使用默认 ${languageCode} 语言包`);
    }

    // 获取默认翻译数据
    getDefaultTranslations(languageCode) {
        const defaultTranslations = {
            'zh-CN': {
                'welcome': '欢迎访问',
                'dashboard': '仪表板',
                'settings': '设置',
                'save': '保存',
                'cancel': '取消',
                'delete': '删除',
                'edit': '编辑',
                'add': '添加',
                'search': '搜索',
                'loading': '加载中...',
                'success': '操作成功',
                'error': '操作失败',
                'confirm': '确认',
                'language': '语言',
                'logout': '退出登录',
                'login': '登录',
                'register': '注册',
                'profile': '个人资料',
                'help': '帮助',
                'about': '关于',
                'contact': '联系我们'
            },
            'en-US': {
                'welcome': 'Welcome',
                'dashboard': 'Dashboard',
                'settings': 'Settings',
                'save': 'Save',
                'cancel': 'Cancel',
                'delete': 'Delete',
                'edit': 'Edit',
                'add': 'Add',
                'search': 'Search',
                'loading': 'Loading...',
                'success': 'Success',
                'error': 'Error',
                'confirm': 'Confirm',
                'language': 'Language',
                'logout': 'Logout',
                'login': 'Login',
                'register': 'Register',
                'profile': 'Profile',
                'help': 'Help',
                'about': 'About',
                'contact': 'Contact Us'
            }
        };
        
        return defaultTranslations[languageCode] || defaultTranslations['zh-CN'];
    }

    // 设置语言切换器
    setupLanguageSwitcher() {
        // 创建语言切换器UI（如果不存在）
        if (!document.getElementById('language-switcher')) {
            this.createLanguageSwitcher();
        }
        
        // 更新语言切换器状态
        this.updateLanguageSwitcher();
    }

    // 创建语言切换器
    createLanguageSwitcher() {
        const switcher = document.createElement('div');
        switcher.id = 'language-switcher';
        switcher.style.cssText = `
            position: fixed;
            top: 20px;
            right: 20px;
            z-index: 1000;
            background: white;
            border-radius: 8px;
            box-shadow: 0 4px 12px rgba(0,0,0,0.15);
            padding: 10px;
            min-width: 120px;
        `;
        
        switcher.innerHTML = `
            <div style="font-size: 12px; color: #666; margin-bottom: 8px;">语言</div>
            <select id="language-select" style="width: 100%; padding: 6px; border: 1px solid #ddd; border-radius: 4px;">
                ${this.supportedLanguages.map(lang => 
                    `<option value="${lang}">${this.getLanguageName(lang)}</option>`
                ).join('')}
            </select>
        `;
        
        document.body.appendChild(switcher);
        
        // 添加语言切换事件
        document.getElementById('language-select').addEventListener('change', (e) => {
            this.changeLanguage(e.target.value);
        });
    }

    // 获取语言名称
    getLanguageName(languageCode) {
        const languageNames = {
            'zh-CN': '简体中文',
            'zh-TW': '繁体中文',
            'en-US': 'English (US)',
            'en-GB': 'English (UK)',
            'ja-JP': '日本語',
            'ko-KR': '한국어',
            'fr-FR': 'Français',
            'de-DE': 'Deutsch',
            'es-ES': 'Español',
            'es-MX': 'Español (México)',
            'pt-BR': 'Português (BR)',
            'pt-PT': 'Português (PT)',
            'ru-RU': 'Русский',
            'ar-SA': 'العربية',
            'hi-IN': 'हिन्दी',
            'th-TH': 'ไทย',
            'vi-VN': 'Tiếng Việt'
        };
        return languageNames[languageCode] || languageCode;
    }

    // 更新语言切换器
    updateLanguageSwitcher() {
        const select = document.getElementById('language-select');
        if (select) {
            select.value = this.currentLanguage;
        }
    }

    // 切换语言
    async changeLanguage(languageCode) {
        if (!this.supportedLanguages.includes(languageCode)) {
            console.warn(`不支持的语言: ${languageCode}`);
            return;
        }
        
        if (languageCode === this.currentLanguage) {
            return;
        }
        
        console.log(`切换语言到: ${languageCode}`);
        
        // 显示加载状态
        this.showLanguageLoading();
        
        try {
            // 加载新语言的翻译
            if (!this.translations[languageCode]) {
                await this.loadTranslations(languageCode);
            }
            
            // 更新当前语言
            this.currentLanguage = languageCode;
            
            // 保存用户偏好
            localStorage.setItem('userLanguage', languageCode);
            
            // 应用新语言
            this.applyLanguage();
            
            // 更新语言切换器
            this.updateLanguageSwitcher();
            
            console.log(`✅ 语言切换完成: ${languageCode}`);
            
        } catch (error) {
            console.error('语言切换失败:', error);
            this.showNotification('语言切换失败', 'error');
        } finally {
            this.hideLanguageLoading();
        }
    }

    // 显示语言加载状态
    showLanguageLoading() {
        // 可以添加加载动画或提示
        console.log('正在切换语言...');
    }

    // 隐藏语言加载状态
    hideLanguageLoading() {
        // 移除加载状态
        console.log('语言切换完成');
    }

    // 应用当前语言到页面
    applyLanguage() {
        // 更新所有带有 data-i18n 属性的元素
        const elements = document.querySelectorAll('[data-i18n]');
        elements.forEach(element => {
            const key = element.getAttribute('data-i18n');
            const translation = this.translate(key);
            if (translation) {
                element.textContent = translation;
            }
        });
        
        // 更新所有带有 data-i18n-placeholder 属性的输入框
        const inputs = document.querySelectorAll('[data-i18n-placeholder]');
        inputs.forEach(input => {
            const key = input.getAttribute('data-i18n-placeholder');
            const translation = this.translate(key);
            if (translation) {
                input.placeholder = translation;
            }
        });
        
        // 更新页面标题
        const titleElement = document.querySelector('title');
        if (titleElement) {
            const titleKey = titleElement.getAttribute('data-i18n') || 'welcome';
            const translatedTitle = this.translate(titleKey);
            if (translatedTitle) {
                titleElement.textContent = translatedTitle;
            }
        }
        
        console.log(`✅ 语言应用完成: ${this.currentLanguage}`);
    }

    // 翻译文本（支持专有名词保护）
    translate(key, defaultValue = '') {
        if (!this.translations[this.currentLanguage]) {
            return defaultValue || key;
        }
        
        const keys = key.split('.');
        let value = this.translations[this.currentLanguage];
        
        for (const k of keys) {
            if (value && typeof value === 'object' && k in value) {
                value = value[k];
            } else {
                return defaultValue || key;
            }
        }
        
        // 应用专有名词保护
        const protectedValue = this.protectProperNouns(value || defaultValue || key);
        return protectedValue;
    }

    // 专有名词保护功能
    protectProperNouns(text) {
        if (typeof text !== 'string') {
            return text;
        }
        
        // 检查是否启用了专有名词保护
        const protectEnabled = this.getProperNounsProtectionSetting();
        if (!protectEnabled) {
            return text;
        }
        
        // 获取受保护的专有名词列表
        const protectedNouns = this.getProtectedNounsList();
        if (protectedNouns.length === 0) {
            return text;
        }
        
        // 对文本中的专有名词进行保护
        let protectedText = text;
        protectedNouns.forEach(noun => {
            if (noun && noun.trim().length > 0) {
                const regex = new RegExp(`\\b${this.escapeRegExp(noun)}\\b`, 'gi');
                protectedText = protectedText.replace(regex, `{{PROTECTED:${noun}}}`);
            }
        });
        
        return protectedText;
    }

    // 获取专有名词保护设置
    getProperNounsProtectionSetting() {
        // 尝试从系统设置管理器获取设置
        if (window.systemSettingsManager && window.systemSettingsManager.settings) {
            return window.systemSettingsManager.settings.language?.protectProperNouns || true;
        }
        
        // 从本地存储获取设置
        const storedSettings = localStorage.getItem('systemSettings');
        if (storedSettings) {
            try {
                const settings = JSON.parse(storedSettings);
                return settings.language?.protectProperNouns || true;
            } catch (error) {
                console.warn('解析本地存储设置失败:', error);
            }
        }
        
        // 默认启用保护
        return true;
    }

    // 获取受保护的专有名词列表
    getProtectedNounsList() {
        // 尝试从系统设置管理器获取列表
        if (window.systemSettingsManager && window.systemSettingsManager.settings) {
            return window.systemSettingsManager.settings.language?.protectedNouns || [
                'ubike', 'iPhone', 'Google', 'Microsoft', 'Apple', 'Samsung'
            ];
        }
        
        // 从本地存储获取列表
        const storedSettings = localStorage.getItem('systemSettings');
        if (storedSettings) {
            try {
                const settings = JSON.parse(storedSettings);
                return settings.language?.protectedNouns || [
                    'ubike', 'iPhone', 'Google', 'Microsoft', 'Apple', 'Samsung'
                ];
            } catch (error) {
                console.warn('解析本地存储设置失败:', error);
            }
        }
        
        // 默认保护列表
        return ['ubike', 'iPhone', 'Google', 'Microsoft', 'Apple', 'Samsung'];
    }

    // 转义正则表达式特殊字符
    escapeRegExp(string) {
        return string.replace(/[.*+?^${}()|[\\]\\]/g, '\\$&');
    }

    // 恢复受保护的专有名词（在显示前调用）
    restoreProtectedNouns(text) {
        if (typeof text !== 'string') {
            return text;
        }
        
        const regex = /\{\{PROTECTED:([^}]+)\}\}/g;
        return text.replace(regex, (match, noun) => {
            return noun;
        });
    }

    // 应用当前语言到页面（增强版，支持专有名词保护）
    applyLanguage() {
        // 更新所有带有 data-i18n 属性的元素
        const elements = document.querySelectorAll('[data-i18n]');
        elements.forEach(element => {
            const key = element.getAttribute('data-i18n');
            const translation = this.translate(key);
            if (translation) {
                // 恢复受保护的专有名词
                const finalText = this.restoreProtectedNouns(translation);
                element.textContent = finalText;
            }
        });
        
        // 更新所有带有 data-i18n-placeholder 属性的输入框
        const inputs = document.querySelectorAll('[data-i18n-placeholder]');
        inputs.forEach(input => {
            const key = input.getAttribute('data-i18n-placeholder');
            const translation = this.translate(key);
            if (translation) {
                // 恢复受保护的专有名词
                const finalText = this.restoreProtectedNouns(translation);
                input.placeholder = finalText;
            }
        });
        
        // 更新页面标题
        const titleElement = document.querySelector('title');
        if (titleElement) {
            const titleKey = titleElement.getAttribute('data-i18n') || 'welcome';
            const translatedTitle = this.translate(titleKey);
            if (translatedTitle) {
                // 恢复受保护的专有名词
                const finalTitle = this.restoreProtectedNouns(translatedTitle);
                titleElement.textContent = finalTitle;
            }
        }
        
        console.log(`✅ 语言应用完成: ${this.currentLanguage}`);
    }

    // 设置回退语言
    setupFallbackLanguage() {
        this.currentLanguage = 'zh-CN';
        this.supportedLanguages = ['zh-CN', 'en-US'];
        this.translations = this.getDefaultTranslations('zh-CN');
        console.log('使用回退语言配置');
    }

    // 显示通知
    showNotification(message, type = 'info') {
        // 创建临时通知元素
        const notification = document.createElement('div');
        notification.style.cssText = `
            position: fixed;
            top: 20px;
            right: 20px;
            padding: 15px 20px;
            border-radius: 6px;
            color: white;
            z-index: 1001;
            font-size: 14px;
            box-shadow: 0 4px 12px rgba(0,0,0,0.15);
            transition: all 0.3s;
            max-width: 300px;
        `;
        
        const colors = {
            success: '#28a745',
            error: '#dc3545',
            info: '#17a2b8',
            warning: '#ffc107'
        };
        
        notification.style.background = colors[type] || colors.info;
        notification.textContent = message;
        
        document.body.appendChild(notification);
        
        // 自动消失
        setTimeout(() => {
            notification.style.opacity = '0';
            notification.style.transform = 'translateX(100%)';
            setTimeout(() => {
                document.body.removeChild(notification);
            }, 300);
        }, 3000);
    }

    // 导出语言包
    exportLanguagePack(languageCode = null) {
        const lang = languageCode || this.currentLanguage;
        const translations = this.translations[lang] || this.getDefaultTranslations(lang);
        
        const languagePack = {
            version: '1.0',
            timestamp: new Date().toISOString(),
            language: lang,
            translations: translations
        };
        
        // 创建下载链接
        const blob = new Blob([JSON.stringify(languagePack, null, 2)], { type: 'application/json' });
        const url = URL.createObjectURL(blob);
        const a = document.createElement('a');
        a.href = url;
        a.download = `language-pack-${lang}-${new Date().toISOString().split('T')[0]}.json`;
        document.body.appendChild(a);
        a.click();
        document.body.removeChild(a);
        URL.revokeObjectURL(url);
        
        this.showNotification(`语言包导出成功: ${lang}`, 'success');
    }

    // 导入语言包
    importLanguagePack(file) {
        return new Promise((resolve, reject) => {
            const reader = new FileReader();
            reader.onload = (e) => {
                try {
                    const languagePack = JSON.parse(e.target.result);
                    
                    // 验证语言包格式
                    if (!languagePack.language || !languagePack.translations) {
                        throw new Error('无效的语言包格式');
                    }
                    
                    // 更新翻译数据
                    this.translations[languagePack.language] = languagePack.translations;
                    
                    // 如果导入的语言是当前语言，立即应用
                    if (languagePack.language === this.currentLanguage) {
                        this.applyLanguage();
                    }
                    
                    this.showNotification(`语言包导入成功: ${languagePack.language}`, 'success');
                    resolve(languagePack);
                    
                } catch (error) {
                    this.showNotification(`语言包导入失败: ${error.message}`, 'error');
                    reject(error);
                }
            };
            reader.onerror = () => {
                this.showNotification('文件读取失败', 'error');
                reject(new Error('文件读取失败'));
            };
            reader.readAsText(file);
        });
    }

    // 同步翻译（模拟）
    async syncTranslations() {
        this.showNotification('正在同步翻译...', 'info');
        
        // 模拟同步过程
        return new Promise((resolve) => {
            setTimeout(() => {
                // 这里可以添加实际的翻译同步逻辑
                // 例如：调用翻译API、更新数据库等
                
                this.showNotification('翻译同步完成', 'success');
                resolve();
            }, 2000);
        });
    }
}

// 创建全局实例
window.i18nManager = new I18nManager();

// 页面加载完成后初始化
document.addEventListener('DOMContentLoaded', function() {
    window.i18nManager.init();
});

// 全局翻译函数
window.t = function(key, defaultValue = '') {
    return window.i18nManager ? window.i18nManager.translate(key, defaultValue) : (defaultValue || key);
};

// 全局语言切换函数
window.changeLanguage = function(languageCode) {
    if (window.i18nManager) {
        window.i18nManager.changeLanguage(languageCode);
    }
};